This presentation and accompanying materials are available on 🔗 UCLA OARC GitHub Repository

You can view the slides in:

• 📄 PDF format - WS_HPC-GPU.pdf
• 🌐 HTML format: Workshop Slides

Each file provides detailed instructions and examples on the various topics covered in this workshop.

Note: 🛠️ This presentation was built using Quarto and RStudio.

git clone https://github.com/ucla-oarc-hpc/WS_HPC-GPU.git

GPUs are ubiquitous and found in devices ranging from PCs to mobile phones, and gaming consoles like Xbox and PlayStation.

Though initially designed for graphics, GPUs are now used in a wide range of applications.

There are multiple GPU types available in the cluster.

Each GPU has a different compute capability, memory size and clock speed.

qrsh -l h_data=40G,h_rt=1:00:00,gpu,A100,cuda=1

#SBATCH -l gpu,A100,cuda=1

On Hoffman2, you can compile CUDA code by loading the cuda module. This will modify the environment to from the CUDA toolkit. This Toolkit provides the necessary libraries and compilers to compile and run CUDA code.

modules_lookup -m cuda

module load cuda/11.8

We will so a simple example of a CUDA code that does a Matrix multiplication (1024x1024).

• Files are in the MatrixMult folder
  • Matrix-cpu.cpp file contains CPU (serial) code
  • Matrix-gpu.cu file contains the CUDA code
  • MatrixMult.job job submission file

module load gcc/10.2.0
module load cuda/12.3

g++ -o Matrix-cpu Matrix-cpu.cpp
nvcc -o Matrix-gpu Matrix-gpu.cu

qsub MatrixMult.job

Be on the lookout for GPU optimized software for your research!

Other GPU platforms include:

modules_lookup -m hpcsdk

modules_lookup -m amd

There are several Python and R packages that use GPUs for varsious data-intensives tasks, like Machine Learning, Deep Learning, and large-scale data processing.

Installing TensorFlow and PyTorch on Hoffman2 is straightforward using the Anaconda package manager. (Check out my Workshop on using Anaconda)

export PYTHON_VER=3.9
export CUDA_TK_VER=11.8
module load anaconda3/2023.03
conda create -n tf_torch_gpu python=${PYTHON_VER} cudatoolkit=${CUDA_TK_VER} pandas cudnn -c anaconda -c conda-forge -c nvidia -y
conda activate tf_torch_gpu

python3 -m pip install tensorflow[and-cuda]==2.14
pip3 install tensorrt tensorrt-bindings tensorrt-libs --extra-index-url https://pypi.nvidia.com
pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu${CUDA_TK_VER//./}
pip3 install scikit-learn

# TensofFlow Test:
python -c "import tensorflow as tf; print('TensorFlow is using:', ('GPU: ' + tf.test.gpu_device_name()) if tf.test.is_gpu_available() else 'CPU')"

# PyTorch Test:
python -c "import torch; print('PyTorch is using:', ('GPU: ' + torch.cuda.get_device_name(0)) if torch.cuda.is_available() else 'CPU')"

This example focuses on the “Fashion MNIST” dataset, a collection used frequently in machine learning for image recognition tasks.

Approach:

• We will use TensorFlow to train a Netural Net model for predicting fashion categories.

Dataset Overview:

• 📸 Images: 28x28 grayscale images of fashion products.
• 📊 Categories: 10, with 7,000 images per category.
• 🧮 Total Images: 70,000.

Now that we have TensorFlow installed, we can run some examples to test the GPU acceleration.

Files in the TF-Torch folder contain examples of using TensorFlow on Hoffman2.

qrsh -l h_data=40G,h_rt=1:00:00,gpu,A100,cuda=1

module load anaconda3/2023.03
conda activate tf_torch_gpu

python minst-train-cpu.py

python minst-train-gpu.py

• 🤖 Model Development: Use PyTorch to build a model predicting the presence of ‘gene’ regions.
• 🚀 Leveraging GPUs: Utilize the parallel processing power of GPUs for efficient training.

With PyTorch installed in the same Anaconda environment, we can now run the DNA classification example.

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

device = torch.device('cpu')

python dnatorch.py

We will

• Applying conditions to filter dataframes based on depth, quality, and allele frequency.
• Grouping data by chromosome and calculating mean statistics for depth, quality, and allele frequency.
• Speed comparison of these operations on GPU versus CPU.

Rapids is a suite of open-source software libraries and APIs built on CUDA to enable execution of end-to-end data science and analytics pipelines on GPUs. cuDF is a GPU DataFrame library for loading, joining, aggregating, filtering, and otherwise manipulating data.

In this example, we will use cuDF to load and filter genomic data efficiently using GPU accelaration

Files in the rapids folder

• rapids_analysis-gpu.py - GPU version
• rapids_analysis-cpu.py - CPU version

The rapid_analysis.job will submit the job to the Hoffman2 cluster.

In this file, the line #$ -l gpu,V100 will submit this job to the V100 GPU nodes.

qsub rapids_analysis.job

We will use R and install the H2O.ai package to run the example.

• Setting up the environment

module load cuda/11.8 
module load gcc/10.2.0
module load R/4.3.0

• Installing H2O.ai in R

install.packages(c("RCurl", "jsonlite"))
install.packages("h2o", type="source", repos=(c("http://h2o-release.s3.amazonaws.com/h2o/latest_stable_R")))

In the h2oai folder, the h2oaiXGBoost.R script the code to run XGBoost on the Combined Cycle Power Plant dataset.

qsub h2oML-gpu.job

qsub h2oML-cpu.job

The h2o.ai functions will automatically detect the GPU and use it for training.

Questions? Comments?

• cpeterson@oarc.ucla.edu

• Look at for more Hoffman2 workshops